home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 06 - 1990 / 06.03 Mar 90 / XCMD Mar Code / •Listing 3•MiniParser.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-06  |  4.5 KB  |  222 lines  |  [TEXT/KAHL]
  1. /********************************/
  2. /* File: ParseCommands.c        */
  3. /*                                */
  4. /* Parse commands coming in from*/
  5. /* Hypercard.                    */
  6. /*                                */
  7. /* Once the object is parsed, it*/
  8. /* is added to the draw list for*/
  9. /* the window.                    */
  10. /*                                 */
  11. /* Eventually need to match     */
  12. /* multiple tokens so that we     */
  13. /* can have parameters such as:    */
  14. /* BOLD&ITALIC&OUTLINE            */
  15. /* ----------------------------    */
  16. /* © 1989 Donald Koscheka        */
  17. /* All Rights Reserved            */
  18. /********************************/
  19.  
  20. #define        CR                    0x0D
  21. #define        NEWLINE                0x0D
  22. #define        LF                    0x0A
  23. #define        TAB                    0x09
  24. #define        ETX                    0x03    /* the enter key */
  25.  
  26. long matchToken( buf, tabl )
  27.     Handle    buf;
  28.     short    tabl;
  29. /*******************************
  30. * given an input buffer and the resource 
  31. * id of the parse table, return 
  32. * the token that represents the input
  33. * string.
  34. *
  35. * A token of 0 is returned if no
  36. * match is found.  This way, you
  37. * can use the first item in the list
  38. * as the default item!
  39. *
  40. * The symbol table should have the 
  41. * format:
  42. *
  43. *    <string>, <token>
  44. * 
  45. * where string mathces to the input
  46. * string and token is that value for 
  47. * a given match.
  48. *******************************/
  49. {
  50.     char    *bp;            /*** pointer to input strings            ***/
  51.     Handle    strH;            /*** handle to parse strings resource    ***/
  52.     long    token     = 0;    /*** return the default if no match        ***/
  53.     short    indx    = 0;
  54.     short    theID;
  55.     ResType    theType;    
  56.     short    done = 0;
  57.     long    len;
  58.     char    theNum[31];    
  59.     char    *np;
  60.     char    theName[256];
  61.     char    theString[256];
  62.         
  63.     bp = *buf;
  64.     
  65.     while( *bp ){
  66.         toUpper( *bp );
  67.         bp++;
  68.     }
  69.     
  70.     strH     = GetResource( 'STR#', tabl );
  71.     
  72.     if( strH ){
  73.         
  74.         GetResInfo( strH, &theID, &theType, &theName );
  75.         
  76.         /*** compare the string to the allowable tokens ***/
  77.         indx    = 1 ;
  78.         
  79.         while( !done ){
  80.             theString[0] = '\0';
  81.             GetIndString( &theString, tabl, indx );
  82.             
  83.             if( theString[0] == '\0' ){    /* no strings matched the input     */
  84.                 done = 1;
  85.             }
  86.             else{                        /* attempt to match to current str    */
  87.                 
  88.                 PtoCstr( (char *)&theString );
  89.                 
  90.                 len = 0;
  91.                 
  92.                 bp = theString;
  93.                 while ( *bp != ',' ){
  94.                     bp++;
  95.                     len++;
  96.                 }
  97.             
  98.                 if( strncmp( *buf, (char *)theString, len ) == 0){
  99.                     /* have a match so extract the token    */                    
  100.                     
  101.                     /*** move past any garbage in the string ***/
  102.                     while( (*bp < '0' || *bp > '9') && *bp != '-')
  103.                         bp++;
  104.                     
  105.                     /*** now copy what bp points to into a     ***/
  106.                     /*** a pascal style string                ***/
  107.                     
  108.                     theNum[0] = '\0';
  109.                     np = &theNum[1];
  110.                     
  111.                     while( *bp >= '0' && *bp <= '9' ){
  112.                         theNum[0]++;
  113.                         *np++ = *bp++;
  114.                     }
  115.                     
  116.                     /*** np is a valid p-string                ***/
  117.                     StringToNum( theNum, &token );
  118.                     done = 1;
  119.                 }
  120.                 else
  121.                     indx++;
  122.             }
  123.         }
  124.     }
  125.     
  126.     return( token );
  127. }
  128.  
  129.  
  130. long    parseNum( bp )
  131.             char    *bp;
  132. /***********************
  133. * parse the data stream 
  134. * and return a numeric 
  135. * value.  The stream is null
  136. * terminated.
  137. *
  138. ***********************/
  139. {
  140.     long    num = 0;
  141.     
  142.     char    theString[256];
  143.     short    done = 0;
  144.     char    *ps;
  145.         
  146.     /*** move the input pointer until we're looking at a number    ***/
  147.     while( *bp && ( *bp < '0' || *bp > '9' ) && *bp != '-' )
  148.         bp++;
  149.     
  150.     /*** copy the data into a pascal string     ***/
  151.     ps    = theString;
  152.     ps++;
  153.     
  154.     while( *bp >= '0' && *bp <= '9' )
  155.         *ps++ = *bp++;
  156.     
  157.     /*** moved one past the output so try this    ***/
  158.     theString[0] = (char)( ps - theString -1  );    
  159.     StringToNum( theString, &num );
  160.     
  161.     return( num );    
  162. }
  163.  
  164. char    *nextToken( bp )
  165.             char    *bp;
  166. /***********************
  167. * given a pointer to an
  168. * input stream, move to the 
  169. * next token in the stream. 
  170. * 
  171. * Token's are delineated by
  172. * ',' or whitespace
  173. *
  174. * Assumes we are pointing to the current token
  175. * Move past the current token and the white
  176. * space that follows it.
  177. ***********************/
  178. {
  179.     /*** move past the current token    ***/
  180.     while( *bp &&(*bp != ',' && *bp != SPACE && *bp != CR && *bp != LF && *bp != TAB) )
  181.         bp++;
  182.  
  183.     /*** move past the white space to the next token    ***/
  184.     while( *bp == ',' || *bp == SPACE || *bp == CR || *bp == LF || *bp == TAB )
  185.         bp++;
  186.     
  187.     return( bp );
  188. }
  189.  
  190. void     parseRect( buf, theRect )
  191.             Handle    buf;
  192.             Rect    *theRect;
  193. /***********************
  194. * parse the data stream 
  195. * into a rectangle
  196. *
  197. * default is the NULL rect
  198. ***********************/
  199. {
  200.     char    *bp;
  201.     
  202.     theRect->top = theRect->left = theRect->bottom = theRect->right = 0;
  203.     
  204.     if( validHandle( buf ) ){
  205.         HLock( buf );
  206.         
  207.         bp = *buf;
  208.         theRect->top = parseNum( bp );
  209.         bp    = nextToken( bp );
  210.         
  211.         theRect->left = parseNum( bp );
  212.         bp    = nextToken( bp );
  213.         
  214.         theRect->bottom = parseNum( bp );
  215.         bp    = nextToken( bp );
  216.         
  217.         theRect->right = parseNum( bp );
  218.         bp    = nextToken( bp );
  219.         
  220.         HUnlock( buf );
  221.     }
  222. }